/**
 * 功能：切换数组元素
 * @param {Array} arr 要切换元素的数组
 * @param {any} val 要切换的值
 */
export function toggle (arr, val) {
  var index = arr.indexOf(val)

  if (index === -1) {
    arr.push(val)
  } else {
    arr.splice(index, 1)
  }

  return arr
}

/**
 * 功能: 比较两个数组是否包含相同的元素
 */
export function equal (arr1, arr2) {
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) return false
  if (arr1 === arr2) return true
  if (arr1.length !== arr2.length) return false

  for (let i = 0; i < arr1.length; i++) {
    if (!arr2.includes(arr1[i])) return false
  }

  return true
}

/**
 * 功能: 删除数组的某一项
 * @param {Array} arr 要删除元素的数组
 * @param {Any} item 要删除的数组项
 * @param {Boolean} all 相同的项是否全部删除, 默认只删除第一个找到的项
 */
export function del (arr, item, all) {
  if (all) {
    while (arr.includes(item)) {
      arr.splice(arr.indexOf(item), 1)
    }
  } else {
    if (arr.includes(item)) {
      arr.splice(arr.indexOf(item), 1)
    }
  }

  return arr
}

/**
 * 功能: 按模式获取数组中的对象
 * @param {Array} arr 查找项的数组
 * @param {Object} mode 匹配模式
 * @param {Boolean} isInclude 是否开启模糊查找
 * @param {Boolean} all 是否找到匹配模式全部的项，默认只找到第一项
 * @return {Array} 返回找到的结果数组，默认只包含一项，启用all后，有可能包含多项
 */
export function findMode (arr, mode, isInclude, all = false) {
  let keys = Object.keys(mode)
  let result = []

  for (let i = 0; i < arr.length; i++) {
    let curr = arr[i]

    for (var j = 0; j < keys.length; j++) {
      let matching = isInclude
        ? (!`${curr[keys[j]]}`.includes(mode[keys[j]]))
        : mode[keys[j]] !== curr[keys[j]]

      if (matching) {
        break
      }
    }

    if (j === keys.length) {
      result.push(curr)

      if (!all) {
        return result
      }
    }
  }

  return result
}

/**
 * 功能: 返回索引
 * @param {Array} arr 查找项的数组
 * @param {Object} mode 匹配模式
 * @param {Boolean} isInclude 是否开启模糊查找
 * @return {Array} 返回找到的结果数组，默认只包含一项，启用all后，有可能包含多项
 */
export function indexMode (arr, mode, isInclude) {
  let keys = Object.keys(mode)

  for (let i = 0; i < arr.length; i++) {
    let curr = arr[i]

    for (var j = 0; j < keys.length; j++) {
      let matching = isInclude
        ? (!`${curr[keys[j]]}`.includes(mode[keys[j]]))
        : mode[keys[j]] !== curr[keys[j]]

      if (matching) {
        break
      }
    }

    if (j === keys.length) {
      return i
    }
  }

  return -1
}

/**
 * 功能: 数组是否有指定的匹配模式项
 * @param {Array} arr 查找匹配模式的数组
 * @param {Object} mode 匹配模式
 * @param {Boolean} isInclude 是否开启模糊查找
 */
export function hasMode (arr, mode, isInclude) {
  return findMode(arr, mode, isInclude).length > 0
}

/**
 * 功能: 数组元素调换位置上移下移
 * @param {Array} arr 要上移下移的数组
 * @param {Number} index1 下移元素的下标
 * @param {Number} index2 上移元素的下标
 */
export function swap (arr, index1, index2) {
  arr[index1] = arr.splice(index2, 1, arr[index1])[0]
  return arr
}

/**
     * 将字符串数组转换成哈希对象， 其生成的hash对象的key为数组中的元素， value为1
     * @method listToMap
     * @param { Array } arr 字符串数组
     * @return { Object } 转化之后的hash对象
     */
export function listToMap (list) {
  if (!list) return {}
  list = Array.isArray(list) ? list : list.split(',')
  for (var i = 0, ci, obj = {}; (ci = list[i++]);) {
    obj[ci.toUpperCase()] = obj[ci] = 1
  }
  return obj
}

/**
 * 找出数组中重复的元素
 * @param { Array } arr 字符串数组
 * @return { Array }  newList 数组中重复的元素
 */
export function findDuplicates (arr) {
  let newArr = []
  arr.sort((a, b) => {
    return a - b
  })
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] === arr[i + 1] && (newArr.indexOf(arr[i]) === -1)) {
      newArr.push(arr[i])
      i++
    }
  }

  return newArr
}

/**
 * sort方法自定义排序函数 适用于题号 先按整数部分排序，再按小数部分排序
 * @param {String} a 字符1
 * @param {String} b 字符2
 */
export function sortQuestionNums (a, b) {
  let as = a.toString().split('.')
  let bs = b.toString().split('.')
  if (parseInt(as[0]) === parseInt(bs[0]) && (as[1] || bs[1])) {
    if (as[1] && bs[1]) {
      return as[1] - bs[1]
    } else if (as[1]) {
      return 1
    } else {
      return -1
    }
  } else {
    return a - b
  }
}
